home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Moscow ML 1.31 / source code / ANSIshellƒ / os_mac_eStyle.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-04  |  22.7 KB  |  801 lines  |  [TEXT/R*ch]
  1. /* os_mac_eStyle.c
  2.  * 2Jun92  e
  3.  */
  4.  
  5. #ifdef THINK_C
  6. #include <MacHeaders>
  7. #else
  8. #ifdef __MWERKS__
  9. #else
  10. "Unknown compiler!"
  11. #endif
  12. #endif
  13.  
  14. /*
  15. #include <Dialogs.h>
  16. #include <Controls.h>
  17. #include <QuickDraw.h>
  18. #include <Windows.h>
  19. #include <ToolUtils.h>
  20. #include <OSUtils.h>
  21. #include <Menus.h>
  22. #include <Fonts.h>
  23. #include <resources.h>
  24. */
  25.  
  26. #include "os_mac.h"
  27.  
  28. /* extensions to an editor for text files by e
  29.    questions/comments via Internet <e@Flavors.COM>
  30. */
  31. /* Copyright © e 1992. All rights reserved.
  32.     Developed using THINK C 5.0.1 for use with Gambit Scheme.
  33.     This code may be freely distributed as long as this notice remains.
  34. */
  35.  
  36. /* to do:
  37. 06Jun92  e
  38. consider checkbox to modify OK to:
  39. - Set Style for All Windows
  40. consider showing text in style
  41. - (let ((the 3) (quick 5) (brown 7)) (fox jumps over the lazy dog))
  42. - ((lambda (the quick brown) (fox jumps over (the lazy) dog)) 3 5 7)
  43. consider a way to save Window's style in the file
  44. consider a way to save Creation style (preferences)
  45. add a Use Outline Fonts checkbox
  46. */
  47.  
  48. #define MAXFONTSIZE 1023
  49.  
  50. /* resources */
  51.  
  52. #define esdID        357
  53.  
  54. /* dialog items */
  55.  
  56. #define esdOK         1
  57. #define esdCancel     2
  58. #define esdTabsEt     3
  59. #define esdTabsSt     4
  60. #define esdFont1St     5
  61. #define esdFont1Pu     6
  62. #define esdSize1St     7
  63. #define esdSize1Et     8
  64. #define esdBold1Cb     9
  65. #define esdItal1Cb    10
  66. #define esdCond1Cb    11
  67. #define esdUndr1Cb    12
  68. #define esdInvr1Cb    13
  69. #define esdExpd1Cb    14
  70. #define esdFont2St    15
  71. #define esdFont2Pu    16
  72. #define esdSize2St    17
  73. #define esdSize2Et    18
  74. #define esdBold2Cb    19
  75. #define esdItal2Cb    20
  76. #define esdCond2Cb    21
  77. #define esdUndr2Cb    22
  78. #define esdInvr2Cb    23
  79. #define esdExpd2Cb    24
  80. #define esdPS1St    25
  81. #define esdPS2St    26
  82. #define esdSize1Pu    27
  83. #define esdSize2Pu    28
  84. #define esdOutline1    29
  85. #define esdOutline2    30
  86. #define esdOKring    31
  87. #define esdThisBt    32
  88. #define esdPrefBt    33
  89. #define esdDfltBt    34
  90. #define esdGetSt    35
  91. #define esdOutline3    36
  92. #define esdApplSt    37
  93. #define esdThisCb    38
  94. #define esdPrefCb    39
  95. #define esdWrapEt    40
  96. #define esdAutoInd    42
  97.  
  98. /* the pop-up font item */
  99.  
  100. /* See: Apple Macintosh Developer Technical Support
  101.         Pop-up Menu Example Application
  102.         PopMenus.p
  103. */
  104.  
  105. static TextStyle tsNewPri, tsNewAlt;
  106. static short tabsNew;
  107. static short wrapNew;
  108. static short autoIndNew;
  109.  
  110. #define popMenuID1 128
  111. static MenuHandle popMenu1;
  112. static Rect  popUpBox1;        /* boundsrect of font popUp1 */
  113. static Rect  promptBox1;    /* boundsrect of its title */
  114. static short fontChoice1;    /* its last chosen item */
  115.  
  116. #define popMenuID2 129
  117. static MenuHandle popMenu2;
  118. static Rect  popUpBox2;        /* boundsrect of font popUp2 */
  119. static Rect  promptBox2;    /* boundsrect of its title */
  120. static short fontChoice2;    /* its last chosen item */
  121.  
  122. #define popMenuID3 130
  123. static MenuHandle popMenu3;
  124. static Rect  popUpBox3;        /* boundsrect of font popUp2 */
  125. static short sizeChoice3;    /* its last chosen item */
  126.  
  127. #define popMenuID4 131
  128. static MenuHandle popMenu4;
  129. static Rect  popUpBox4;        /* boundsrect of font popUp2 */
  130. static short sizeChoice4;    /* its last chosen item */
  131.  
  132. /* some user item action procs -- used in update events mostly */
  133.  
  134. #define leftSlop 15
  135. #define rightSlop 17
  136. #define botSlop 5
  137.  
  138. static void drawPopArrow( Rect r )
  139. { 
  140.   FrameRect( &r );
  141.   MoveTo( r.right, r.top+2 );
  142.   LineTo( r.right, r.bottom );
  143.   LineTo( r.left+2, r.bottom );
  144.   MoveTo( r.right-17, r.top+6 );
  145.   Line( 11, 0 );
  146.   Move( -10, 1 );
  147.   Line( 9, 0 );
  148.   Move( -8, 1);
  149.   Line( 7, 0 );
  150.   Move( -6, 1);
  151.   Line( 5, 0 );
  152.   Move( -4, 1 );
  153.   Line( 3, 0 );
  154.   Move( -2, 1 );
  155.   Line( 1, 0 );
  156. }
  157.  
  158. static pascal void DrawPopUpSz( DialogPtr dwind, short dinum )
  159. { short itemtype;
  160.   Handle itemhandle;
  161.   Rect r;
  162.   GetDItem( dwind, dinum, &itemtype, &itemhandle, &r );
  163.   InsetRect( &r, -1, -1 );
  164.   drawPopArrow( r );
  165. }
  166.  
  167. static void DrawPopUpX( MenuHandle popMenu, Rect* popUpBox, short lastChoice )
  168. { Rect r;
  169.   Str255 curFont;
  170.   short newWid, newLen, wid;
  171.  
  172.   GetItem( popMenu, lastChoice, curFont ); /* get currently-selected item */
  173.   r = *popUpBox;
  174.   EraseRect( &r );
  175.   InsetRect( &r, -1, -1 );
  176.   /* Make sure the title fits. Truncate it and add an ellipses (“…”) otherwise */
  177.   wid = (r.right - r.left) - (leftSlop + rightSlop);
  178.   newWid = StringWidth( curFont );
  179.   if( newWid > wid )
  180.   { newLen = curFont[0]; /* current length in characters */
  181.     wid = wid - CharWidth('…');
  182.     do
  183.     { newWid = newWid - CharWidth( curFont[newLen--] );
  184.     } while( ( newWid > wid ) && ( newLen > 0 ) );
  185.     curFont[++newLen] = '…';
  186.     curFont[0] = newLen;
  187.   }
  188.   drawPopArrow( r );
  189.   MoveTo( r.left+leftSlop, r.bottom-botSlop);
  190.   DrawString( curFont );
  191. }
  192.  
  193. static pascal void DrawPopUp1( DialogPtr theDialog, short theItem )
  194. { DrawPopUpX( popMenu1, &popUpBox1, fontChoice1 );
  195. }
  196.  
  197. static pascal void DrawPopUp2( DialogPtr theDialog, short theItem )
  198. { DrawPopUpX( popMenu2, &popUpBox2, fontChoice2 );
  199. }
  200.  
  201. /* BorderDefault draws a heavy border around the default ( OK ) button */
  202. static pascal void BorderDefault( WindowPtr dwind, short dinum )
  203. { short itemtype;
  204.   Handle itemhandle;
  205.   Rect borderRect;
  206.   GetDItem( dwind, esdOK, &itemtype, &itemhandle, &borderRect );
  207.   InsetRect( &borderRect, -4, -4 );
  208.   PenSize( 3, 3 );
  209.   FrameRoundRect( &borderRect, 16, 16 );
  210.   PenSize( 1, 1 );
  211. }
  212.  
  213. /* Outliner draws a light border around the the user item */
  214. static pascal void Outliner( WindowPtr dwind, short dinum )
  215. { short itemtype;
  216.   Handle itemhandle;
  217.   Rect borderRect;
  218.   GetDItem( dwind, dinum, &itemtype, &itemhandle, &borderRect );
  219.   /* InsetRect( &borderRect, -4, -4 ); */
  220.   PenSize( 1, 1 );
  221.   FrameRoundRect( &borderRect, 16, 16 );
  222. }
  223.  
  224. /* util fcns. */
  225.  
  226. /* cursor to IBeam if it's over an active edit line, arrow if it's not */
  227. void IBeamIt( WindowPtr dwind )
  228. { Point mouseAt;
  229.   short itemtype;
  230.   Handle itemhandle;
  231.   Rect borderRect;
  232.   short itemNum;
  233.   /* first get the current edit line out of the dialog record */
  234.   itemNum = ((DialogPeek )dwind)->editField + 1; /* always stored 1 less */
  235.   GetDItem( dwind, itemNum, &itemtype, &itemhandle, &borderRect );
  236.   GetMouse( &mouseAt );
  237.   if( PtInRect( mouseAt, &borderRect ) )
  238.     SetCursor(&ibeam_cursor);
  239.   else
  240.     SetCursor(&qd.arrow);
  241. }
  242.  
  243. static void pseudoClick( DialogPtr dbox, short item )
  244. { short itemtype;
  245.   Rect itemrect;
  246.   Handle hC;
  247.   long tilticks;
  248.   GetDItem( dbox, item, &itemtype, &hC, &itemrect );
  249.   HiliteControl( (ControlHandle)hC, inButton );
  250.   Delay( 8, &tilticks );
  251.   HiliteControl( (ControlHandle)hC, false );
  252. }
  253.  
  254. static short apndMenu( MenuHandle hM, Str255 title, short itemno, Boolean check, Boolean realfont )
  255. {
  256.   AppendMenu( hM, title );
  257.   if( realfont ) SetItemStyle( hM, itemno, outline );
  258.   if( check )
  259.   { SetItemMark( hM, itemno, checkMark );
  260.     return itemno;
  261.   }
  262.   return 0;
  263. }
  264.  
  265. static MenuHandle sizeMenu( short id, short *ckitem, short fNum, short curSize )
  266. { MenuHandle hM;
  267.   Str255 oddSize;
  268.   short match = 0;
  269.   hM = NewMenu( id, "\p" );
  270.   match |= apndMenu( hM,  "\p9", 1, (curSize ==  9), RealFont( fNum,  9 ) );
  271.   match |= apndMenu( hM, "\p10", 2, (curSize == 10), RealFont( fNum, 10 ) );
  272.   match |= apndMenu( hM, "\p12", 3, (curSize == 12), RealFont( fNum, 12 ) );
  273.   match |= apndMenu( hM, "\p14", 4, (curSize == 14), RealFont( fNum, 14 ) );
  274.   match |= apndMenu( hM, "\p18", 5, (curSize == 18), RealFont( fNum, 18 ) );
  275.   match |= apndMenu( hM, "\p24", 6, (curSize == 24), RealFont( fNum, 24 ) );
  276.   if( match == 0 )
  277.   { NumToString( (long )curSize, oddSize );
  278.     InsMenuItem( hM, oddSize, 0 );
  279.     InsMenuItem( hM, "\p(-", 1 );
  280.     SetItemMark( hM, 1, checkMark );
  281.     if( RealFont( fNum, curSize ) ) SetItemStyle( hM, 1, outline );
  282.     *ckitem = 1;
  283.   }
  284.   else *ckitem = match;
  285.   return( hM );
  286. }
  287.  
  288. static short doPop( DialogPtr esd, MenuHandle popMenu, Rect popUpBox, short id, short oldChoice )
  289. { long chosen;
  290.   Point popLoc;
  291.   short newChoice;
  292.   InsertMenu( popMenu, -1 );
  293.   popLoc = topLeft(popUpBox);
  294.   LocalToGlobal( &popLoc );
  295.   CalcMenuSize( popMenu ); /* Work around Menu Mgr bug */
  296.   chosen = PopUpMenuSelect( popMenu, popLoc.v, popLoc.h, oldChoice );
  297.   DeleteMenu( id );
  298.   if( chosen != 0 )
  299.   { newChoice = LoWord(chosen);
  300.     if( newChoice != oldChoice )
  301.     { SetItemMark( popMenu, oldChoice, ' ' );
  302.       SetItemMark( popMenu, newChoice, checkMark );
  303.       EraseRect( &popUpBox );
  304.       return( newChoice );
  305.     }
  306.   }
  307.   return 0;
  308. }
  309.  
  310. /* filter proc */
  311.  
  312. #define kReturnKey 0x0D
  313. #define kEnterKey 0x03
  314. #define kEscKey 0x1B
  315. #define kTabKey 9
  316. enum  {
  317.     kBackSpace = 8,
  318.     kLeftArrow = 0x1C, kRightArrow, kUpArrow, kDownArrow,
  319.     kDeleteKey = 0x7F
  320. };
  321.  
  322. /* size menu selection => edit text box */
  323. static void doSize1( DialogPtr esd )
  324. { Rect tempRect;
  325.   short tempItem;
  326.   Handle tempHandle;
  327.   long tmp;
  328.   Str255 tStr;
  329.   GetDItem( esd, esdSize1Et, &tempItem, &tempHandle, &tempRect );
  330.   GetItem( popMenu3, sizeChoice3, tStr );
  331.   SetIText( tempHandle, tStr );
  332.   SelIText( esd, esdSize1Et, 0, 32767 );
  333.   StringToNum( tStr, &tmp);
  334.   tsNewPri.tsSize = tmp;
  335. }
  336.  
  337. /* size menu selection => edit text box */
  338. static void doSize2( DialogPtr esd )
  339. { Rect tempRect;
  340.   short tempItem;
  341.   Handle tempHandle;
  342.   long tmp;
  343.   Str255 tStr;
  344.   GetDItem( esd, esdSize2Et, &tempItem, &tempHandle, &tempRect );
  345.   GetItem( popMenu4, sizeChoice4, tStr );
  346.   SetIText( tempHandle, tStr );
  347.   SelIText( esd, esdSize2Et, 0, 32767 );
  348.   StringToNum( tStr, &tmp);
  349.   tsNewAlt.tsSize = tmp;
  350. }
  351.  
  352. /* font menu selection triggers update of size menu */
  353. static void doFont1( void )
  354. { Str255 tStr;
  355.   GetItem( popMenu1, fontChoice1, tStr );
  356.   GetFNum( tStr, &tsNewPri.tsFont );
  357.   if( popMenu3 ) DisposHandle( (Handle )popMenu3 );
  358.   popMenu3 = sizeMenu( popMenuID3, &sizeChoice3, tsNewPri.tsFont, tsNewPri.tsSize );
  359. }
  360.  
  361. /* font menu selection triggers update of size menu */
  362. static void doFont2( void )
  363. { Str255 tStr;
  364.   GetItem( popMenu2, fontChoice2, tStr );
  365.   GetFNum( tStr, &tsNewAlt.tsFont );
  366.   if( popMenu4 ) DisposHandle( (Handle )popMenu4 );
  367.   popMenu4 = sizeMenu( popMenuID4, &sizeChoice4, tsNewAlt.tsFont, tsNewAlt.tsSize );
  368. }
  369.  
  370. /* this function always returns a value between 1 and MAXFONTSIZE inclusive */
  371. /* an out of range number returns 8;
  372.    this is so font sizes and tab stops are reasonable */
  373. static long etToNum( DialogPtr dbox, short item )
  374. { short tempItem;
  375.   Rect tempRect;
  376.   Handle tempHandle;
  377.   long tmp;
  378.   Str255 tStr;
  379.   GetDItem( dbox, item, &tempItem, &tempHandle, &tempRect );
  380.   GetIText( tempHandle, tStr );
  381.   StringToNum( tStr, &tmp);
  382.   if( tmp > MAXFONTSIZE || tmp < 1 ) tmp = 8;
  383.   return tmp;
  384. }
  385.  
  386. /* update size menu if size edit text box changed */
  387. static void preSize1( DialogPtr esd )
  388. { long tmp;
  389.   tmp = etToNum( esd, esdSize1Et );
  390.   if( tsNewPri.tsSize != tmp )
  391.   { tsNewPri.tsSize = tmp;
  392.     if( popMenu3 ) DisposHandle( (Handle )popMenu3 );
  393.     popMenu3 = sizeMenu( popMenuID3, &sizeChoice3, tsNewPri.tsFont, tsNewPri.tsSize );
  394.   }
  395. }
  396.  
  397. /* update size menu if size edit text box changed */
  398. static void preSize2( DialogPtr esd )
  399. { long tmp;
  400.   tmp = etToNum( esd, esdSize2Et );
  401.   if( tsNewAlt.tsSize != tmp )
  402.   { tsNewAlt.tsSize = tmp;
  403.     if( popMenu4 ) DisposHandle( (Handle )popMenu4 );
  404.     popMenu4 = sizeMenu( popMenuID4, &sizeChoice4, tsNewAlt.tsFont, tsNewAlt.tsSize );
  405.   }
  406. }
  407.  
  408. pascal Boolean filterIt( DialogPtr esd, EventRecord *myDialogEvent, short *theDialogItem)
  409. { WindowPtr temp;
  410.   char theKey;
  411.   Rect tempRect;
  412.   short tempItem;
  413.   Handle tempHandle;
  414.   Boolean result = false;
  415.  
  416.   GetPort( &temp );
  417.   SetPort( esd );
  418.     
  419.   IBeamIt( esd ); /* make IBeam cursor when over the active edit line */
  420.     
  421.   /* do standard filtering for escape and return as OK and Cancel aliases */
  422.   /* invert the button in the dialog, so the user get's visual feedback */
  423.  
  424.   if ((myDialogEvent->what == keyDown) || (myDialogEvent->what == autoKey))
  425.   { theKey = myDialogEvent->message & charCodeMask;
  426.     if( (myDialogEvent->modifiers & (cmdKey|controlKey|optionKey)) == 0 )
  427.     { switch( theKey )
  428.       { case kReturnKey:
  429.         case kEnterKey:
  430.             *theDialogItem = esdOK;
  431.             pseudoClick( esd, esdOK );
  432.           SetPort(temp);
  433.           result = true;
  434.           break;
  435.         case kEscKey:
  436.           *theDialogItem = esdCancel;
  437.           pseudoClick( esd, esdCancel );
  438.           SetPort(temp);
  439.           result = true;
  440.           break;
  441.         case kTabKey:
  442.         case kBackSpace:
  443.         case kLeftArrow:
  444.         case kRightArrow:
  445.         case kUpArrow:
  446.         case kDownArrow:
  447.         case kDeleteKey:
  448.             break;
  449.         default:
  450.           /* filter out non-numeric keys */
  451.           if( theKey < 0x30 || theKey > 0x39 )
  452.           { SysBeep( 1 );
  453.             SetPort( temp );
  454.             result = true;
  455.           }
  456.           break;
  457.       }
  458.     }
  459.   }
  460.   else if( myDialogEvent->what == mouseDown )
  461.   { Point mouseLoc;
  462.     short newChoice;
  463.     mouseLoc = ( myDialogEvent->where );
  464.     GlobalToLocal( &mouseLoc );
  465.     switch( newChoice = FindDItem( esd, mouseLoc ) + 1 )
  466.     { case esdFont1St:
  467.       case esdFont1Pu:
  468.         InvertRect( &promptBox1 );
  469.         newChoice = doPop( esd, popMenu1, popUpBox1, popMenuID1, fontChoice1 );
  470.         InvertRect( &promptBox1 );
  471.         if( newChoice != 0 )
  472.         { fontChoice1 = newChoice;
  473.           DrawPopUp1( esd, esdFont1Pu );
  474.           *theDialogItem = esdFont1Pu;
  475.           SetPort( temp );
  476.           result = true;
  477.         }
  478.         break;
  479.       case esdFont2St:
  480.       case esdFont2Pu:
  481.         InvertRect( &promptBox2 );
  482.         newChoice = doPop( esd, popMenu2, popUpBox2, popMenuID2, fontChoice2 );
  483.         InvertRect( &promptBox2 );
  484.         if( newChoice != 0 )
  485.         { fontChoice2 = newChoice;
  486.           DrawPopUp2( esd, esdFont2Pu );
  487.           *theDialogItem = esdFont2Pu;
  488.           SetPort( temp );
  489.           result = true;
  490.         }
  491.         break;
  492.       /* case esdSize2St:  not for size menu!? */
  493.       case esdSize1Pu:
  494.           SelIText( esd, esdSize1Et, 0, 32767 );
  495.           preSize1( esd );
  496.         newChoice = doPop( esd, popMenu3, popUpBox3, popMenuID3, sizeChoice3 );
  497.         if( newChoice != 0 )
  498.         { sizeChoice3 = newChoice;
  499.           DrawPopUpSz( esd, esdSize1Pu );
  500.           *theDialogItem = esdSize1Pu;
  501.           SetPort( temp );
  502.           result = true;
  503.         }
  504.         break;
  505.       /* case esdSize2St:  not for size menu!? */
  506.       case esdSize2Pu:
  507.           SelIText( esd, esdSize2Et, 0, 32767 );
  508.           preSize2( esd );
  509.         newChoice = doPop( esd, popMenu4, popUpBox4, popMenuID4, sizeChoice4 );
  510.         if( newChoice != 0 )
  511.         { sizeChoice4 = newChoice;
  512.           DrawPopUpSz( esd, esdSize2Pu );
  513.           *theDialogItem = esdSize2Pu;
  514.           SetPort( temp );
  515.           result = true;
  516.         }
  517.         break;
  518.     }
  519.   }
  520.   return( result );
  521. }
  522.  
  523. static void check( DialogPtr dbox, short item, Boolean mark )
  524. { ControlHandle hC;
  525.   short itemtype;
  526.   Rect itemrect;    
  527.   GetDItem( dbox, item, &itemtype, (Handle *)&hC, &itemrect);
  528.   SetCtlValue( hC, mark );
  529. }
  530.  
  531. static void checks( DialogPtr dbox, short style, short offs )
  532. {
  533.   check( dbox, esdBold1Cb + offs, ( style & bold ) ? 1 : 0 );
  534.   check( dbox, esdItal1Cb + offs, ( style & italic ) ? 1 : 0 );
  535.   check( dbox, esdUndr1Cb + offs, ( style & underline ) ? 1 : 0 );
  536.   check( dbox, esdCond1Cb + offs, ( style & condense ) ? 1 : 0 );
  537.   check( dbox, esdExpd1Cb + offs, ( style & extend ) ? 1 : 0 );
  538.   /*
  539.   check( dbox, esdInvr1Cb + offs, ( style & bold ) ? 1 : 0 );
  540.   */
  541. }
  542.  
  543. short checklist[] = { bold, italic, condense, underline, 0x80, extend };
  544.  
  545. static short findFontItem( MenuHandle hM, short fontNum )
  546. { short result = 1;
  547.   short i, fn;
  548.   Str255 tStr;
  549.   for( i = CountMItems( hM ); i > 0; i-- )
  550.   { GetItem( hM, i, tStr );
  551.     GetFNum( tStr, &fn );
  552.     if( fn == fontNum ) return i;
  553.     if( fn == 0 ) result = i;
  554.   }
  555.   return result;
  556. }
  557.  
  558. /* get the item's rect & set the procPtr */
  559. static void initUserItem( DialogPtr esd, short item, Rect *pRect, UserItemUPP pProc )
  560. { short tempItem;
  561.   Handle tempHandle;
  562.   GetDItem( esd, item, &tempItem, &tempHandle, pRect );
  563.   SetDItem( esd, item, tempItem, (Handle )pProc, pRect );
  564. }
  565.  
  566. static void hosePops( void )
  567. {
  568.   if( popMenu1 ) DisposHandle( (Handle )popMenu1 );
  569.   popMenu1 = 0;
  570.   if( popMenu2 ) DisposHandle( (Handle )popMenu2 );
  571.   popMenu2 = 0;
  572.   if( popMenu3 ) DisposHandle( (Handle )popMenu3 );
  573.   popMenu3 = 0;
  574.   if( popMenu4 ) DisposHandle( (Handle )popMenu4 );
  575.   popMenu4 = 0;
  576. }
  577.  
  578. static void initPops( DialogPtr esd )
  579. { Str255 tStr;
  580.   short tempItem;
  581.   Rect tempRect;
  582.   Handle tempHandle;
  583.  
  584.   hosePops();
  585.   
  586.   SetPort( esd );
  587.   
  588.   popMenu1 = NewMenu( popMenuID1, "\p" );
  589.   AddResMenu( popMenu1, 'FONT' );
  590.   fontChoice1 = findFontItem( popMenu1, tsNewPri.tsFont );
  591.   SetItemMark( popMenu1, fontChoice1, checkMark );
  592.   InvalRect( &popUpBox1 );
  593.     
  594.   popMenu2 = NewMenu( popMenuID2, "\p" );
  595.   AddResMenu( popMenu2, 'FONT' );
  596.   fontChoice2 = findFontItem( popMenu2, tsNewAlt.tsFont );
  597.   SetItemMark( popMenu2, fontChoice2, checkMark );
  598.   InvalRect( &popUpBox2 );
  599.   
  600.   popMenu3 = sizeMenu( popMenuID3, &sizeChoice3, tsNewPri.tsFont, tsNewPri.tsSize );
  601.   doSize1( esd );
  602.  
  603.   popMenu4 = sizeMenu( popMenuID4, &sizeChoice4, tsNewAlt.tsFont, tsNewAlt.tsSize );
  604.   doSize2( esd );
  605.   
  606.   checks( esd, tsNewPri.tsFace,  0 );
  607.   checks( esd, tsNewAlt.tsFace, 10 );
  608.   
  609.   NumToString( (long )tabsNew, tStr );
  610.   GetDItem( esd, esdTabsEt, &tempItem, &tempHandle, &tempRect );
  611.   SetIText( tempHandle, tStr );
  612.   SelIText( esd, esdTabsEt, 0, 32767 );
  613.   
  614.   NumToString( (long )wrapNew, tStr );
  615.   GetDItem( esd, esdWrapEt, &tempItem, &tempHandle, &tempRect );
  616.   SetIText( tempHandle, tStr );
  617.   SelIText( esd, esdWrapEt, 0, 32767 );
  618.  
  619.   check( esd, esdAutoInd, autoIndNew );
  620. }
  621.  
  622. static suppinit = 0;
  623. ModalFilterUPP filterItUPP;
  624. UserItemUPP DrawPopUp1UPP;
  625. UserItemUPP DrawPopUp2UPP;
  626. UserItemUPP DrawPopUpSzUPP;
  627. UserItemUPP OutlinerUPP;
  628. UserItemUPP BorderDefaultUPP;
  629.  
  630. void eStyleDlg( eRec **hE /* , TextStyle *pri, TextStyle *alt */ )
  631. { DialogPtr esd = NULL;
  632.   short hitItem = 0;
  633.   short tempItem;
  634.   Rect tempRect;
  635.   Handle tempHandle;
  636.   Boolean tBool;
  637.   long tmp1, tmp2, tmp3;
  638.  
  639.   if ( ! suppinit )
  640.   { filterItUPP = NewModalFilterProc(filterIt);
  641.     DrawPopUp1UPP  = NewUserItemProc(DrawPopUp1);
  642.     DrawPopUp2UPP  = NewUserItemProc(DrawPopUp2);
  643.     DrawPopUpSzUPP = NewUserItemProc(DrawPopUpSz);
  644.     OutlinerUPP    = NewUserItemProc(Outliner);
  645.     BorderDefaultUPP = NewUserItemProc(BorderDefault);
  646.     suppinit = 1;
  647.   }
  648.   
  649.   tsNewPri = (**hE).style[0];
  650.   tsNewAlt = (**hE).style[1];
  651.   tabsNew = (**hE).tabStops;
  652.   wrapNew = (**hE).wrap;
  653.   autoIndNew = (**hE).autoInd;
  654.  
  655.   /* Get a dialog box, and set up our useritems */
  656.   esd = GetNewDialog( esdID, NULL, (WindowPtr)(-1) );
  657.         
  658.   /* Find out where our useritems are, and set their item handles to be
  659.      a pointer to our popup-drawing or other special procedure */
  660.   GetDItem( esd, esdFont1St, &tempItem, &tempHandle, &promptBox1 ); /* get the title rect */
  661.   initUserItem( esd, esdFont1Pu, &popUpBox1, DrawPopUp1UPP ); /* universal header kludge 7Jun94 e */
  662.   GetDItem( esd, esdFont2St, &tempItem, &tempHandle, &promptBox2 ); /* get the title rect */
  663.   initUserItem( esd, esdFont2Pu, &popUpBox2, DrawPopUp2UPP ); /* universal header kludge 7Jun94 e */
  664.   initUserItem( esd, esdSize1Pu, &popUpBox3, DrawPopUpSzUPP ); /* universal header kludge 7Jun94 e */
  665.   initUserItem( esd, esdSize2Pu, &popUpBox4, DrawPopUpSzUPP ); /* universal header kludge 7Jun94 e */
  666.   initUserItem( esd, esdOutline1, &tempRect, OutlinerUPP ); /* universal header kludge 7Jun94 e */
  667.   initUserItem( esd, esdOutline2, &tempRect, OutlinerUPP ); /* universal header kludge 7Jun94 e */
  668.   initUserItem( esd, esdOutline3, &tempRect, OutlinerUPP ); /* universal header kludge 7Jun94 e */
  669.  
  670.   GetDItem( esd, esdOK,&tempItem, &tempHandle, &tempRect ); /* get the OK button's rect */
  671.   InsetRect( &tempRect, -4, -4);
  672.   SetDItem( esd, esdOKring, userItem+itemDisable, (Handle )BorderDefaultUPP, &tempRect);
  673.  
  674.   /* Get two menus containing the current set of fonts */
  675.   /* and two menus containing their corresponding sizes */
  676.   initPops( esd );
  677.   
  678.   check( esd, esdThisCb, 1 );
  679.   check( esd, esdPrefCb, 0 );    /* defaulted to off  --  16Jul92  e  */
  680.     
  681.   ShowWindow( (WindowPtr)esd );
  682.   DrawDialog( esd );
  683.   do
  684.   { ModalDialog( filterItUPP, &hitItem );
  685.     switch ( hitItem )
  686.     { case esdFont1Pu:
  687.         doFont1( );
  688.         break;
  689.       case esdFont2Pu:
  690.         doFont2( );
  691.         break;
  692.       case esdSize1Pu:
  693.           doSize1( esd );
  694.         break;
  695.       case esdSize2Pu:
  696.           doSize2( esd );
  697.         break;
  698.       case esdBold1Cb:
  699.       case esdItal1Cb:
  700.       case esdCond1Cb:
  701.       case esdUndr1Cb:
  702.       case esdInvr1Cb:
  703.       case esdExpd1Cb:
  704.         GetDItem( esd, hitItem, &tempItem, &tempHandle, &tempRect);
  705.         tempItem = GetCtlValue( (ControlHandle )tempHandle ) ^ 1;
  706.         if( tempItem == 0 )
  707.           tsNewPri.tsFace &= ~checklist[hitItem-esdBold1Cb];
  708.         else
  709.           tsNewPri.tsFace |=  checklist[hitItem-esdBold1Cb];
  710.         SetCtlValue( (ControlHandle )tempHandle, tempItem);
  711.         break;
  712.       case esdBold2Cb:
  713.       case esdItal2Cb:
  714.       case esdCond2Cb:
  715.       case esdUndr2Cb:
  716.       case esdInvr2Cb:
  717.       case esdExpd2Cb:
  718.         GetDItem( esd, hitItem, &tempItem, &tempHandle, &tempRect);
  719.         tempItem = GetCtlValue( (ControlHandle )tempHandle ) ^ 1;
  720.         if( tempItem == 0 )
  721.           tsNewAlt.tsFace &= ~checklist[hitItem-esdBold2Cb];
  722.         else
  723.           tsNewAlt.tsFace |=  checklist[hitItem-esdBold2Cb];
  724.         SetCtlValue( (ControlHandle )tempHandle, tempItem);
  725.         break;
  726.       case esdThisCb:
  727.       case esdPrefCb:
  728.       case esdAutoInd:
  729.         GetDItem( esd, hitItem, &tempItem, &tempHandle, &tempRect);
  730.         tempItem = GetCtlValue( (ControlHandle )tempHandle ) ^ 1;
  731.         SetCtlValue( (ControlHandle )tempHandle, tempItem);
  732.         break;
  733.       case esdThisBt:
  734.         tsNewPri = (**hE).style[0];
  735.         tsNewAlt = (**hE).style[1];
  736.         tabsNew =  (**hE).tabStops;
  737.         wrapNew =  (**hE).wrap;
  738.         autoIndNew = (**hE).autoInd;
  739.         initPops( esd );
  740.         break;
  741.       case esdPrefBt:
  742.         tsNewPri = prefStylNormal;
  743.         tsNewAlt = prefStylHilite;
  744.         tabsNew  = prefTabs;
  745.         wrapNew  = prefWrap;
  746.         autoIndNew = prefAutoInd;
  747.         initPops( esd );
  748.         break;
  749.       case esdDfltBt:
  750.         tsNewPri = dfltStylNormal;
  751.         tsNewAlt = dfltStylHilite;
  752.         tabsNew  = dfltTabs;
  753.         wrapNew  = dfltWrap;
  754.         autoIndNew = dfltAutoInd;
  755.         initPops( esd );
  756.         break;
  757.     }
  758.   } while ( hitItem != esdOK && hitItem != esdCancel );
  759.   
  760.   if( hitItem == esdOK )
  761.   { tsNewPri.tsSize = etToNum( esd, esdSize1Et );
  762.     tsNewAlt.tsSize = etToNum( esd, esdSize2Et );
  763.     tmp1 = etToNum( esd, esdTabsEt );
  764.     tmp2 = etToNum( esd, esdWrapEt );
  765.     GetDItem( esd, esdAutoInd, &tempItem, &tempHandle, &tempRect);
  766.     tmp3 = GetCtlValue( (ControlHandle )tempHandle );
  767.     GetDItem( esd, esdThisCb, &tempItem, &tempHandle, &tempRect);
  768.     if( GetCtlValue( (ControlHandle )tempHandle ) )
  769.     { if( (**hE).tabStops != tmp1 )
  770.       { eTeSetTabStop( hE, (short )tmp1 );
  771.       }
  772.       if( (**hE).wrap != tmp2 )
  773.       { eTeSetWrap( hE, (short )tmp2 );
  774.       }
  775.       (**hE).autoInd = tmp3;
  776.       if(    tsNewPri.tsFont != (**hE).style[0].tsFont
  777.           || tsNewPri.tsSize != (**hE).style[0].tsSize
  778.           || tsNewPri.tsFace != (**hE).style[0].tsFace
  779.           || tsNewAlt.tsFont != (**hE).style[1].tsFont
  780.           || tsNewAlt.tsSize != (**hE).style[1].tsSize
  781.           || tsNewAlt.tsFace != (**hE).style[1].tsFace
  782.         )
  783.       { eTeSetStyles( hE, &tsNewPri, &tsNewAlt );
  784.       }
  785.     }
  786.     GetDItem( esd, esdPrefCb, &tempItem, &tempHandle, &tempRect);
  787.     if( GetCtlValue( (ControlHandle )tempHandle ) )
  788.     { prefStylNormal = tsNewPri;
  789.       prefStylHilite = tsNewAlt;
  790.       prefTabs    = (short )tmp1;
  791.       prefWrap    = (short )tmp2;
  792.       prefAutoInd = (short )tmp3;
  793.       savePrefs( PREFS_FILENAME );  /*  16Jul92  e  */
  794.     }
  795.   }
  796.   hosePops();
  797.   if( esd ) DisposDialog( esd );
  798. }
  799.  
  800. /* end of os_mac_eStyle.c */
  801.